package com.chentf.data.datastructure.arrays;

import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

/**
 * 动态数组
 */
public class DynamicArray implements Iterable<Integer>{

    private int size = 0; //逻辑大小
    private int capacity = 8; //容量
    private int[] array = {};

    public int[] array(){
        // 该函数使用Arrays工具类中的方法，复制一维数组array，并截取指定的长度size返回新的数组副本
        return Arrays.copyOf(array,size);
    }

    /**
     * 想最后位置[size]添加元素
     * @param element
     */
    public void addLast(int element){
//        array[size] = element;
//        size ++;
        add(size,element);
    }

    /**
     * 向 [0 .. size] 位置添加元素
     * @param index   索引位置
     * @param element 待添加元素
     */
    public void add(int index,int element){
        checkAndGrow();
        //添加元素逻辑
        if(index > 0 && index < size){
            //向后挪动，空出带插入位置,从index开始，到size结束
            System.arraycopy(array,index,array,index + 1,size - index);
        }
        array[index] = element;
        size++;
    }

    private void checkAndGrow(){
        // 容量检查
        if(size == 0){
            array = new int[capacity];
        }else if(size == capacity){
            // 进行扩容，1.5,1.618,2
            capacity += capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array,0,newArray,0,size);
            array = newArray;
        }
    }

    /**
     * 从 [0 .. size) 范围删除元素
     *
     * @param index 索引位置
     * @return 被删除元素
     */
    public int remove(int index){
        int removed = array[index];
        if(index < size - 1){
            //向前挪动
            System.arraycopy(array,index + 1,array,index,size - index - 1);
        }
        size--;
        return removed;
    }

    /**
     * 查找元素
     * @param index 索引位置，在[0,sizie)区间内
     * @return 该索引位置的元素
     */
    public int get(int index){
        return array[index];
    }

    /**
     * 遍历方法1
     *
     * @param consumer 遍历要执行的操作, 入参: 每个元素
     */
    public void foreach(Consumer<Integer> consumer){
        for(int i = 0; i < size; i++){
            // 提供array[i],返回void
            consumer.accept(array[i]);
        }
    }


    /**
     * 遍历方法2 迭代器遍历
     * @return
     */
    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;
            @Override
            public boolean hasNext() { // 有没有下一个元素
                return i < size;
            }

            @Override
            public Integer next() { //返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    /**
     * 遍历方法3 - stream遍历
     * @return stream流
     */
    public IntStream stream(){
        return IntStream.of(Arrays.copyOfRange(array,0,size));
    }
}
